package chapter_14;

// java.lang研究

/*
java.lang被自动导入所有的程序。它所包含的类和接口对所有实际的Java程序都是必要的。
它是Java最广泛使用的包。
java.lang包括了下面这些类：
Boolean Long StrictMath (Java 2,1.3)
Byte Math String
Character Number StringBuffer
Class Object System
ClassLoader Package (Java 2) Thread
Compiler Process >ThreadGroup
Double Runtime ThreadLocal (Java 2)
Float >RuntimePermission (Java 2) Throwable
>InheritableThreadLocal (Java 2) SecurityManager Void
>Integer >Short >
另外还有两个由Character定义的类：Character.Subset和Character.UnicodeBlock。
java.lang也定义了如下的接口：
· Cloneable
· Comparable
· Runnable
 */


/*
14.1 简单类型包装器
在本书的第1部分，我们提到因为性能的原因，Java使用简单的类型，例如整型（int）
和字符（char）。这些数据类型不是对象层次结构的组成部分。它们通过值传递给方法而
不能直接通过引用传递。而且，也没有办法使两种方法对整型（int）引用同一实例（same
instance）。有时需要对这些简单的类型建立对象表达式。例如在第15章中讨论的仅仅处理
对象的枚举类；如果要将简单类型存储到这些类中的一个，需要在类中包装简单类型。为
了满足这种需要，Java提供了与每一个简单类型相应的类。本质上，这些类在类中包装
（wrap）简单类型。因此，它们通常被称作类型包装器（wrappers）。
    14.1.1 Number
    抽象类Number定义了一个由包装数字类型字节型（byte），短整型（short），整型（int），
    长整型（long），浮点型（float）和双精度型（double）的类实现的超类。Number有返回上
    面不同数字格式的对象值的抽象方法。也就是，doubleValue( )方法返回双精度（double）
    值，floatValue( )方法返回浮点（float）值等。这些方法如下：
    byte byteValue( )
    double doubleValue( )
    float floatValue( )
    int intValue( )
    long longValue( )
    short shortValue( )
    这些方法的返回值可以被舍入。
    Number有6个具体的子类包含了6种数字类型的显式值：双精度型（Double），浮点型
    （Float），字节型（Byte），短整型（Short），整型（Integer）和长整型（Long）。

    14.1.2 Double和Float
    双精度（Double）和浮点（Float）分别是对类型double和类型float的浮点值的包装器。
    浮点（Float）构造函数如下所示：
    Float(double num)
    Float(float num)
    Float(String str) 引发NumberFormatException异常
    正如你所看到的，浮点（Float）对象可以由类型float或类型double的值创建。它们也能
    由浮点数的字符串表达式创建。
    双精度（Double）构造函数如下：
    Double(double num)
    Double(String str) 引发NumberFormatException异常
    双精度（Double）对象可以被双精度（double）值或包含了浮点值的字符串创建。
    浮点（Float）和双精度（Double）都定义了下面的常数：
    MAX_VALUE 最大正值
    MIN_VALUE 最小正值
    NaN 非数字
    POSITIVE_INFINITY 正无穷
    NEGATIVE_INFINITY 负无穷
    TYPE 浮点（float）或双精度（double）的类（Class）对象
    理解isInfinite( )和isNaN( )
    浮点（Float）和双精度（Double）提供了isInfinite( )和isNaN( )方法，这些方法会有助
    于操作两个特殊的双精度（double）和浮点（float）值，这些方法检验两个由IEEE浮点规
    范定义的独特的值：无穷和NaN（非具体数字）。当被检验的值为无穷大或无穷小值时，
    isInfinite( )方法返回true。当被检验值为非数字时，isNaN( )方法返回true。

    14.1.3 Byte, Short, Integer 和 Long
    Byte，Short，Integer，和Long类分别是字节型（byte），短整型（short），整型（int）
    和长整型（long）整数类型的包装器。它们的构造函数如下：
    Byte(byte num)
    Byte(String str) 引发一个NumberFormatException异常
    Short(short num)
    Short(String str) 引发一个NumberFormatException异常
    Integer(int num)
    Integer(String str) 引发一个NumberFormatException异常
    Long(long num)
    Long(String str) 引发一个NumberFormatException异常
    正如你能看到的，这些对象可由数值或含有有效整数值的字符串创建。

    定义下面的常数：
    MIN_VALUE 最小值
    MAX_VALUE 最大值
    TYPE 字节（Byte），短整型（short），整型（int）或长整型（long）的类（Class）对象。
    数字和字符串的转换
    程序设计中一个最常见的任务是将一个数字的字符串表达式转换成内部的二进制格
    式。幸运的是Java提供了一个方便的方法去完成这项任务。Byte，Short，Integer和Long类
    分别提供了parseByte( )，parseShort( )，parseInt( )和parseLong( )方法。这些方法返回与调用
    它们的数值字符串相应的字节（byte），短整型（short），整型（int）和长整型（long）值
    （在Float和Double类中也有相似的方法）。

    14.1.4 Character
    字符（Character）是围绕字符型（char）的一个简单的包装器。字符（Character）的构
    造函数如下：
    Character(char ch)
    这里ch指定了被创建的字符（Character）对象所包装的字符。
    调用如下的charValue( )方法可以获得包含在字符（Character）对象中的字符型（char）
    值。
    char charValue( )
    调用的结果返回字符。
    字符（Character）类定义了几个常数，包括下面这些：
    MAX_RADIX 最大基数
    MIN_RADIX 最小基数
    MAX_VALUE 最大字符值
    MIN_VALUE 最小字符值
    TYPE 字符型（char）的类（Class）对象

    14.1.5 Boolean
    Boolean是一个围绕布尔（boolean）值的非常细小的包装器，主要用在通过引用传递布
    尔（boolean）变量的场合。它包含了常数TRUE和FALSE，这些常数定义了布尔（Boolean）
    对象的真与假。Boolean也定义了TYPE域，它是boolean的Class对象。在Boolean中定义了如
    下的构造函数：
    Boolean(boolean boolValue)
    Boolean(String boolString)
    在第一种形式中，boolValue要么是true，要么是false。在第二种形式中，如果在boolString
    中包含了字符串“true”（无论是大写形式还是小写形式），则新的布尔（Boolean）对象
    将为真，否则为假。
 */


/*
14.2 Void
Void类有一个TYPE域，该域保存对类型void的Class对象的引用。这样做将不创建类的
实例。
 */


/*
14.3 Process
抽象类Process封装了一个进程（process）——也就是说一个正在执行的程序。它主要
被当作由Runtime类中的exec( )方法所创建的对象的类型的超类。Runtime类将在下面介绍。
在抽象类Process中。
void destroy( ) 中断进程
int exitValue( ) 返回一个从子进程获得的退出码
InputStream getErrorStream( ) 返回一个从进程的err输出流中读输入的输入流
InputStream getInputStream( ) 返回一个从进程的out输出流中读输入的输入流
OutputStream getOutputStream( ) 返回一个从进程的in输入流中写输出的输出流
Int waitFor( ) throws InterruptedException 返回由进程返回的退出码。这个方法直到
                                            调用它的进程中止，才会返回
 */


/*
14.4 Runtime
Runtime类封装了运行时环境。一般不实例化一个Runtime对象。但是可以通过调用静
态方法Runtime.getRuntime( )而获得对当前Runtime对象的引用。一旦获得了对当前对象的
引用，就可以调用几个控制Java虚拟机的状态和行为的方法。小应用程序（Applets）和其
他不可信赖的编码由于没有引起一个安全异常（SecurityException）而不能调用任何的
Runtime方法。
    14.4.1 内存管理
    尽管Java提供了自动垃圾回收，有时也想知道对象堆的大小以及它还剩下多少。可以
    利用这些信息检验你的代码的效率，或估计对某些类型，有多少对象可以被实例化。为了
    获得这些值，可以使用totalMemory( )和freeMemory( )方法。

    14.4.2 执行其他的程序
    在可靠的环境中，可以在你的多任务操作系统中使用Java去执行其他特别繁重的进程
    （也即程序）。exec( )方法的几种形式允许命名想运行的程序以及它们的输入参数。exec( )
    方法返回一个Process对象，这个对象可以被用来控制你的Java程序如何与这个正在运行的
    新进程相互作用。因为Java可以运行在多种平台和多种操作系统的情况下，exec( )方法本质
    上是依赖于环境的。
 */


/*
14.5 System
System类保存静态方法和变量的集合。标准的输入，输出和Java运行时错误输出存储
在变量in，out和err中。注意当所做操作是安全方式所不允许的时，许多方法引发一个
安全异常（SecurityException）。应当注意的另一点是：Java 2不赞成使用
runFinalizersOnExit( )方法。该方法是在Java 1.1中增加的，同时也被证明是不可靠的。
    14.5.1 使用currentTimeMillis( )记录程序执行的时间
    可以发现System类的一个特别有意义的用法是利用currentTimeMillis( )方法来记录你
    的程序的不同部分的执行时间。currentTimeMillis( )方法返回自从1970年1月1号午夜起到现
    在的时间，时间单位是毫秒。如果要记录你的程序中一段有问题程序的运行时间可以在这
    段程序开始之前存储当前时间，在该段程序结束之际再次调用currentTimeMillis( )方法。执
    行该段程序所花费的时间为其结束时刻的时间值减去其开始时刻的时间值。

    14.5.2 使用arraycopy( )
    使用arraycopy( )方法可以将一个任意类型的数组快速地从一个地方复制到另一个地
    方。这比使用Java中编写的循环要快的多。

    14.5.3 环境属性
    下面的属性在Java 2的所有环境中可以使用：
    file.separator java.vendor.url os.arch
    java.class.path java.version os.name
    java.class.version java.vm.name os.version
    java.ext.dirs java.vm.specification.name Path.separator
    java.home java.vm.specification.vendor User.dir
    java.specification.name java.vm.specification.version User.home
    java.specification.vendor java.vm.vendor User.name
    java.specification.version java.vm.version
    java.vendor line.separator
    可以通过调用System.getProperty( )方法来获得不同环境变量的值。例如下面的程序显
    示当前用户目录的路径：
    class ShowUserDir {
        public static void main(String args[]) {
            System.out.println(System.getProperty("user.dir"));
        }
    }
 */


/*
14.6 Object
超类
 */


/*
14.7 使用clone和Cloneable接口
由Object类定义的绝大部分方法在本书其他部分讨论。而一个特别值得关注的方法是
clone( )。clone( )方法创建调用它的对象的一个复制副本。只有那些实现Cloneable接口的类
能被复制。
Cloneable接口没有定义成员。它通常用于指明被创建的一个允许对对象进行位复制（也
就是对象副本）的类。如果试图用一个不支持Cloneable接口的类调用clone( )方法，将引发
一个CloneNotSupportedException异常。当一个副本被创建时，并没有调用被复制对象的构
造函数。副本仅仅是原对象的一个简单精确的拷贝。
复制是一个具有潜在危险的操作，因为它可能引起不是你所期望的副作用。例如，假
如被复制的对象包含了一个称为obRef的引用变量，当副本创建时，副本中的obRef如同原
对象中的obRef一样引用相同的对象。如果副本改变了被obRef引用的对象的内容，那么对
应的原对象也将被改变。这里是另一个例子。如果一个对象打开一个I/O流并被复制，两个
对象将可操作相同的流。而且，如果其中一个对象关闭了流，而另一个对象仍试图对I/O流
进行写操作的话，将导致错误。
由于复制可能引起问题，因此在Object内，clone( )方法被说明为protected。这就意味着
它必须或者被由实现Cloneable的类所定义的方法调用，或者必须被那些类显式重载以便它
是公共的。
由复制带来的副作用最初一般是比较难发现的。通常很容易想到的是类在复制时是很
安全的，而实际却不是这样。一般在没有一个必须的原因的情况下，对任何类都不应该执
行Cloneable。
 */


/*
14.8 Class
Class封装对象或接口运行时的状态。当类被加载时，类型Class的对象被自动创建。不
能显式说明一个类（Class）对象。一般地，通过调用由Object定义的getClass( )方法来获得
一个类（Class）对象。
 */


/*
14.9 ClassLoader
抽象类ClassLoader规定了类是如何加载的。应用程序可以创建扩展ClassLoader的子类，
实现它的方法。这样做允许使用不同于通常由Java运行时系统加载的另一些方法来加载类。
 */


/*
14.10 Math
Math类保留了所有用于几何学，三角学以及几种一般用途方法的浮点函数。Math定义
了两个双精度（double）常数：E（近似为2.72）和PI（近似为3.14）。
 */


/*
14.11 StrictMath
在Java 2的1.3版本中增加了StrictMath类。这个类定义一个与Math中的数学方法类似的
一套完整的数学方法。两者的区别在于StrictMath中的方法对所有Java工具保证产生精确一
致的结果，而Math中的方法更大程度上是为了提高性能。
 */


/*
14.12 Compiler
Compiler类支持创建将字节码编译而非解释成可执行码的Java环境。常规的程序不使用
它。
 */


/*
14.13 Thread，ThreadGroup和Runnable
Runnable接口以及Thread和ThreadGroup类支持多线程编程。
    14.13.1 Runnable接口
    Runnable接口必须由启动执行的独立线程的类所实现。Runnable仅定义了一种抽象方
    法，叫做run( )。该方法是线程的入口点。它的形式如下所示：
    abstract void run( )
    所创建的线程必须实现该方法。

    14.13.2 Thread
    Thread创建一个新的执行线程。它定义了如下的构造函数：
    Thread( )
    Thread(Runnable threadOb)
    Thread(Runnable threadOb, StringthreadName)
    Thread(String threadName)
    Thread(ThreadGroup groupOb, Runnable threadOb)
    Thread(ThreadGroup groupOb, Runnable threadOb, String threadName)
    Thread(ThreadGroup groupOb, String threadName)
    threadOb是实现Runnable接口的类的一个实例，它定义了线程运行开始的地方。线程的
    名字由threadName指定。当名字未被指定时，Java虚拟机将创建一个。groupOb指定了新线
    程所属的线程组。当没有线程组被指定时，新线程与其父线程属于同一线程组。
    下面的常数由Thread定义：
    MAX_PRIORITY
    MIN_PRIORITY
    NORM_PRIORITY
    正如所期望的那样，这些常数指定了最大，最小以及默认的线程优先权。

    14.13.3 ThreadGroup
    线程组（ThreadGroup）创建了一组线程。它定义了如下的两个构造函数：
    ThreadGroup(String groupName)
    ThreadGroup(ThreadGroup parentOb, String groupName)
    对于两种形式，groupName指定了线程组的名字。第一种形式创建一个新的线程组，
    该线程组将当前的线程作为它的父线程。在第二种形式中，父线程由parentOb指定。
    由ThreadGroup定义的方法列在表14-17中。在比Java 2更早出现的Java版本中，
 */


/*
14.14 ThreadLocal和InheritableThreadLocal
在Java 2的java.lang中增加了两个与线程有关的类：
· ThreadLocal 用于创建线程局部变量。每个线程都拥有自己局部变量的拷贝。
· InheritableThreadLocal 创建可以被继承的线程局部变量。
 */


/*
14.15 Package
在Java 2中增加了一个称为Package的类。这个类封装了与包有关的版本数据。包版本
信息由于包的增值以及由于Java程序可能需要知道哪些包版本可以利用而变得更加重要。
 */


/*
14.16 RuntimePermission
在Java 2的java.lang中也新增加了RuntimePermission。它与Java的安全机制有关，这里
不做进一步的讨论。
 */


/*
14.17 Throwable
Throwable类支持Java的异常处理系统，它是派生所有异常类的类。
 */


/*
14.18 SecurityManager
SecurityManager是一个子类可以实现的抽象类，它用于创建一个安全管理程序。一般
不需要实现自己的安全管理程序，如果非要这样做，需要查阅与你的Java开发系统一起得
到的相关文档。
 */


/*
14.19 Comparable接口
Java 2在java.lang中新增加了一个接口：Comparable。实现Comparable的类的对象可以
被排序。换句话说，实现Comparable的类包含了可以按某种有意义的方式进行比较的对象。
Comparable接口说明了一个方法，该方法用于确定Java 2调用一个类的实例的自然顺序。该
方法如下所示：
int compareTo(Object obj)
这个方法比较调用对象和obj。如果他们相等，就返回0。如果调用对象比obj小，则返
回一个负值。否则返回一个正值。
该接口由前面已经介绍的几种类实现。特别是Byte，Character，Double，Float，Long，
Short，String以及Integer类定义了compareTo( )方法。
 */


/*
14.20 java.lang.ref和java.lang.reflect包
    14.20.1 java.lang.ref
    在前面学到过，在Java中，垃圾回收工具自动确定何时对一个对象，没有引用存在。
    然后这个对象就被认为是不再需要的，同时它所占的内存也被释放。在Java 2中新增加的
    java.lang.ref包中的类对垃圾回收处理提供更加灵活的控制。例如，假设你的程序创建了大
    量的在后面某个时间又想重新使用的对象，可以持续保持对这些对象的引用，但是这可能
    需要更多的内存开销。
    作为替代，可以对这些对象定义“软”引用。如果可以利用的内存接近用完的话，一
    个可以“软实现”的对象可以从垃圾回收工具中释放。在那种情况下，垃圾回收工具将这
    个对象的“软”引用设为空（null）。否则，垃圾回收工具保存对象以便以后使用。
    程序设计人员具有确定是否一个“软实现”的对象被释放的能力。如果它被释放了，
    可以重新创建它。如果没有释放，该对象对于后面的应用将一直是可以利用的。也可以为
    对象创建“弱”（weak）和“假想”（phantom）引用。

    14.20.2 java.lang.reflect
    Reflection是一个程序分析自己的能力。包java.lang.reflect提供了获得关于一个类的域、
    构造函数、方法和修改符的能力。需要这些信息去创建可以使你利用Java Beans组件的软件
    工具。这个工具使用映射动态地确定组件的特征。
 */


public class chapter_14 {
}
